home *** CD-ROM | disk | FTP | other *** search
/ Die Speccy' 97 / Die Speccy' 97.iso / amiga_system / the_aminet / comm / bbs / wwbbs31_source.lha / WWBBS / Library / users.c < prev    next >
C/C++ Source or Header  |  1995-01-28  |  20KB  |  746 lines
  1. #include "wwbbs.h"
  2. #include "users.h"
  3. #include <dos/exall.h>
  4.  
  5. BOOL create_dir(BYTE *);
  6. void delete_dir(BYTE *);
  7.  
  8. __asm
  9. ULONG GetUser(register __a0 struct TagItem *tags_orig)
  10.     {
  11.         ULONG ret=0;
  12.         STRPTR name=NULL;
  13.         STRPTR username=NULL;
  14.         STRPTR realname=NULL;
  15.         STRPTR uucpname=NULL;
  16.         BOOL exists=FALSE;
  17.         BOOL isnext=FALSE;struct Node *next=NULL;
  18.         ULONG *nextreturn=NULL;
  19.         {
  20.             struct TagItem *tags;
  21.             if(tags=CloneTagItems(tags_orig))
  22.                 {
  23.                     if(FilterTagItems(tags,usr_get_tags,TAGFILTER_AND))
  24.                         {
  25.                             struct TagItem *tstate,*tag;
  26.                             APTR data;
  27.                             tstate=tags;
  28.                             while(tag=NextTagItem(&tstate))
  29.                                 {
  30.                                     data=(APTR) tag->ti_Data;
  31.                                     switch(tag->ti_Tag)
  32.                                         {
  33.                                             case USRTAG_Name:
  34.                                                 name=data;
  35.                                                 break;
  36.                                             case USRTAG_UserName:
  37.                                                 username=data;
  38.                                                 break;
  39.                                             case USRTAG_RealName:
  40.                                                 realname=data;
  41.                                                 break;
  42.                                             case USRTAG_UUCPName:
  43.                                                 uucpname=data;
  44.                                                 break;
  45.                                             case USRTAG_Exists:
  46.                                                 exists=(BOOL) data;
  47.                                                 break;
  48.                                             case USRTAG_Next:
  49.                                                 isnext=TRUE;
  50.                                                 next=data;
  51.                                                 break;
  52.                                             case USRTAG_NextReturn:
  53.                                                 nextreturn=data;
  54.                                                 break;
  55.                                             default:
  56.                                                 break;
  57.                                         }
  58.                                 }
  59.                         }
  60.                     FreeTagItems(tags);
  61.                 }
  62.         }
  63.         {
  64.             if(isnext)
  65.                 {
  66.                     struct Node *node=NULL;
  67.                     if(next)
  68.                         {
  69.                             /* next */
  70.                             struct Node *tmp;
  71.                             BYTE tmp_realname[31];
  72.                             strcpy(tmp_realname,"");
  73.                             tmp=next->ln_Succ;
  74.                             if(tmp->ln_Succ)
  75.                                 {
  76.                                     ObtainSemaphoreShared(&(((struct UserNode *) tmp)->un_Semaphore));
  77.                                     strcpy(tmp_realname,((struct UserNode *) tmp)->un_RealName);
  78.                                     ReleaseSemaphore(&(((struct UserNode *) tmp)->un_Semaphore));
  79.                                 }
  80.                             FreeUserNode(next);
  81.                             if(strlen(tmp_realname))
  82.                                 node=GetUserNode(tmp_realname,EXCLUSIVE_LOCK);
  83.                         }
  84.                     else
  85.                         {
  86.                             /* begin */
  87.                             BYTE begin_realname[31];
  88.                             strcpy(begin_realname,"");
  89.                             ObtainSemaphoreShared(&UserSemaphore);
  90.                             if(UserList.lh_Head->ln_Succ)
  91.                                 {
  92.                                     ObtainSemaphoreShared(&(((struct UserNode *) UserList.lh_Head)->un_Semaphore));
  93.                                     strcpy(begin_realname,((struct UserNode *) UserList.lh_Head)->un_RealName);
  94.                                     ReleaseSemaphore(&(((struct UserNode *) UserList.lh_Head)->un_Semaphore));
  95.                                 }
  96.                             ReleaseSemaphore(&UserSemaphore);
  97.                             if(strlen(begin_realname))
  98.                                 node=GetUserNode(begin_realname,EXCLUSIVE_LOCK);
  99.                         }
  100.                     if(node)
  101.                         {
  102.                             ULONG count=0;
  103.                             if(username) { *((STRPTR *) username)=((struct UserNode *) node)->un_UserName; count++; }
  104.                             if(realname) { *((STRPTR *) realname)=((struct UserNode *) node)->un_RealName; count++; }
  105.                             if(uucpname) { *((STRPTR *) uucpname)=((struct UserNode *) node)->un_UUCPName; count++; }
  106.                             if(exists) count++;
  107.                             {
  108.                                 if(IsTag(usrinfo_tags,tags_orig))
  109.                                     {
  110.                                         BOOL buffered;
  111.                                         buffered=LoadUserData(UserInfoFile,node,UNTAG_UserInfo);
  112.                                         count+=GetUserInfoFields(node,tags_orig);
  113.                                         if(buffered) UnLoadUserData(node,UNTAG_UserInfo);
  114.                                     }
  115.                                 if(IsTag(usraccess_tags,tags_orig))
  116.                                     {
  117.                                         BOOL buffered;
  118.                                         buffered=LoadUserData(UserAccessFile,node,UNTAG_UserAccess);
  119.                                         count+=GetUserAccessFields(node,tags_orig);
  120.                                         if(buffered) UnLoadUserData(node,UNTAG_UserAccess);
  121.                                     }
  122.                                 if(IsTag(usrprefs_tags,tags_orig))
  123.                                     {
  124.                                         BOOL buffered;
  125.                                         buffered=LoadUserData(UserPrefsFile,node,UNTAG_UserPrefs);
  126.                                         count+=GetUserPrefsFields(node,tags_orig);
  127.                                         if(buffered) UnLoadUserData(node,UNTAG_UserPrefs);
  128.                                     }
  129.                                 if(IsTag(usrstats_tags,tags_orig))
  130.                                     {
  131.                                         BOOL buffered;
  132.                                         buffered=LoadUserData(UserStatsFile,node,UNTAG_UserStats);
  133.                                         count+=GetUserStatsFields(node,tags_orig);
  134.                                         if(buffered) UnLoadUserData(node,UNTAG_UserStats);
  135.                                     }
  136.                             }
  137.                             if(nextreturn) *nextreturn=count;
  138.                             ret=(ULONG) node;
  139.                         }
  140.                 }
  141.             else
  142.                 {
  143.                     if(name && strlen(name))
  144.                         {
  145.                             struct Node *node;
  146.                             if(node=GetUserNode(name,EXCLUSIVE_LOCK))
  147.                                 {
  148.                                     if(username) { strcpy(username,((struct UserNode *) node)->un_UserName); ret++; }
  149.                                     if(realname) { strcpy(realname,((struct UserNode *) node)->un_RealName); ret++; }
  150.                                     if(uucpname) { strcpy(uucpname,((struct UserNode *) node)->un_UUCPName); ret++; }
  151.                                     if(exists) ret++;
  152.                                     {
  153.                                         if(IsTag(usrinfo_tags,tags_orig))
  154.                                             {
  155.                                                 BOOL buffered;
  156.                                                 buffered=LoadUserData(UserInfoFile,node,UNTAG_UserInfo);
  157.                                                 ret+=GetUserInfoFields(node,tags_orig);
  158.                                                 if(buffered) UnLoadUserData(node,UNTAG_UserInfo);
  159.                                             }
  160.                                         if(IsTag(usraccess_tags,tags_orig))
  161.                                             {
  162.                                                 BOOL buffered;
  163.                                                 buffered=LoadUserData(UserAccessFile,node,UNTAG_UserAccess);
  164.                                                 ret+=GetUserAccessFields(node,tags_orig);
  165.                                                 if(buffered) UnLoadUserData(node,UNTAG_UserAccess);
  166.                                             }
  167.                                         if(IsTag(usrprefs_tags,tags_orig))
  168.                                             {
  169.                                                 BOOL buffered;
  170.                                                 buffered=LoadUserData(UserPrefsFile,node,UNTAG_UserPrefs);
  171.                                                 ret+=GetUserPrefsFields(node,tags_orig);
  172.                                                 if(buffered) UnLoadUserData(node,UNTAG_UserPrefs);
  173.                                             }
  174.                                         if(IsTag(usrstats_tags,tags_orig))
  175.                                             {
  176.                                                 BOOL buffered;
  177.                                                 buffered=LoadUserData(UserStatsFile,node,UNTAG_UserStats);
  178.                                                 ret+=GetUserStatsFields(node,tags_orig);
  179.                                                 if(buffered) UnLoadUserData(node,UNTAG_UserStats);
  180.                                             }
  181.                                     }
  182.                                     FreeUserNode(node);
  183.                                 }
  184.                         }
  185.                 }
  186.         }
  187.         return(ret);
  188.     }
  189.  
  190. ULONG GetUserTags(Tag tag,...)
  191.     {
  192.         return(GetUser((struct TagItem *) &tag));
  193.     }
  194.  
  195. __asm
  196. ULONG SetUser(register __a0 struct TagItem *tags_orig)
  197.     {
  198.         ULONG ret=0;
  199.         STRPTR name=NULL;
  200.         STRPTR username=NULL;
  201.         STRPTR realname=NULL;
  202.         STRPTR uucpname=NULL;
  203.         BOOL forcesave=FALSE;
  204.         BOOL dontsave=FALSE;
  205.  
  206.         BOOL infobuffered=FALSE,accessbuffered=FALSE,prefsbuffered=FALSE,statsbuffered=FALSE;
  207.         BOOL saveindex=FALSE,saveinfo=FALSE,saveaccess=FALSE,saveprefs=FALSE,savestats=FALSE;
  208.         {
  209.             struct TagItem *tags;
  210.             if(tags=CloneTagItems(tags_orig))
  211.                 {
  212.                     if(FilterTagItems(tags,usr_set_tags,TAGFILTER_AND))
  213.                         {
  214.                             struct TagItem *tstate,*tag;
  215.                             APTR data;
  216.                             tstate=tags;
  217.                             while(tag=NextTagItem(&tstate))
  218.                                 {
  219.                                     data=(APTR) tag->ti_Data;
  220.                                     switch(tag->ti_Tag)
  221.                                         {
  222.                                             case USRTAG_Name:
  223.                                                 name=data;
  224.                                                 break;
  225.                                             case USRTAG_UserName:
  226.                                                 username=data;
  227.                                                 break;
  228.                                             case USRTAG_RealName:
  229.                                                 realname=data;
  230.                                                 break;
  231.                                             case USRTAG_UUCPName:
  232.                                                 uucpname=data;
  233.                                                 break;
  234.                                             default:
  235.                                                 break;
  236.                                         }
  237.                                 }
  238.                         }
  239.                     FreeTagItems(tags);
  240.                 }
  241.         }
  242.         {
  243.             if(name && strlen(name))
  244.                 {
  245.                     {
  246.                         struct Node *node;
  247.                         if(node=GetUserNode(name,EXCLUSIVE_LOCK))
  248.                             {
  249.                                 if(IsTag(usrinfo_tags,tags_orig))
  250.                                     {
  251.                                         ULONG num;
  252.                                         infobuffered=LoadUserData(UserInfoFile,node,UNTAG_UserInfo);
  253.                                         num=SetUserInfoFields(node,tags_orig);
  254.                                         ret+=num;
  255.                                         if(num && infobuffered)
  256.                                             {
  257.                                                 saveinfo=TRUE;
  258.                                                 saveindex=TRUE;
  259.                                             }
  260.                                     }
  261.                                 if(IsTag(usraccess_tags,tags_orig))
  262.                                     {
  263.                                         ULONG num;
  264.                                         accessbuffered=LoadUserData(UserAccessFile,node,UNTAG_UserAccess);
  265.                                         num=SetUserAccessFields(node,tags_orig);
  266.                                         ret+=num;
  267.                                         if(num && accessbuffered)
  268.                                             {
  269.                                                 saveaccess=TRUE;
  270.                                                 saveindex=TRUE;
  271.                                             }
  272.                                     }
  273.                                 if(IsTag(usrprefs_tags,tags_orig))
  274.                                     {
  275.                                         ULONG num;
  276.                                         prefsbuffered=LoadUserData(UserPrefsFile,node,UNTAG_UserPrefs);
  277.                                         num=SetUserPrefsFields(node,tags_orig);
  278.                                         ret+=num;
  279.                                         if(num && prefsbuffered)
  280.                                             {
  281.                                                 saveprefs=TRUE;
  282.                                                 saveindex=TRUE;
  283.                                             }
  284.                                     }
  285.                                 if(IsTag(usrstats_tags,tags_orig))
  286.                                     {
  287.                                         ULONG num;
  288.                                         statsbuffered=LoadUserData(UserStatsFile,node,UNTAG_UserStats);
  289.                                         num=SetUserStatsFields(node,tags_orig);
  290.                                         ret+=num;
  291.                                         if(num && statsbuffered)
  292.                                             {
  293.                                                 savestats=TRUE;
  294.                                                 saveindex=TRUE;
  295.                                             }
  296.                                     }
  297.                                 FreeUserNode(node);
  298.                             }
  299.                     }
  300.                     if( (username && strlen(username) && strlen(username)<=32) || (realname && strlen(realname) && strlen(realname)<=30) || (uucpname && strlen(uucpname) && strlen(uucpname)<=32) )
  301.                         {
  302.                             struct Node *node;
  303.                             ObtainSemaphore(&UserSemaphore);
  304.                             if(node=FindUser(name))
  305.                                 {
  306.                                     if(username && strlen(username) && strlen(username)<=32)
  307.                                         {
  308.                                             strcpy(((struct UserNode *) node)->un_UserName,username);
  309.                                             saveindex=TRUE;
  310.                                             ret++;
  311.                                         }
  312.                                     if(realname && strlen(realname) && strlen(realname)<=30)
  313.                                         {
  314.                                             strcpy(((struct UserNode *) node)->un_RealName,realname);
  315.                                             saveindex=TRUE;
  316.                                             ret++;
  317.                                         }
  318.                                     if(uucpname && strlen(uucpname) && strlen(uucpname)<=8)
  319.                                         {
  320.                                             strcpy(((struct UserNode *) node)->un_UUCPName,uucpname);
  321.                                             saveindex=TRUE;
  322.                                             ret++;
  323.                                         }
  324.                                 }
  325.                             ReleaseSemaphore(&UserSemaphore);
  326.                         }
  327.                 }
  328.         }
  329.         {
  330.             if(forcesave || (!dontsave && saveinfo))
  331.                 SaveUserData(UserInfoFile,UNTAG_UserInfo);
  332.             if(forcesave || (!dontsave && saveaccess))
  333.                 SaveUserData(UserAccessFile,UNTAG_UserAccess);
  334.             if(forcesave || (!dontsave && saveprefs))
  335.                 SaveUserData(UserPrefsFile,UNTAG_UserPrefs);
  336.             if(forcesave || (!dontsave && savestats))
  337.                 SaveUserData(UserStatsFile,UNTAG_UserStats);
  338.             if(forcesave || (!dontsave && saveindex))
  339.                 SaveUserIndex(UserIndexFile);
  340.         }
  341.         {
  342.             if(infobuffered || accessbuffered || prefsbuffered || statsbuffered)
  343.                 {
  344.                     if(name && strlen(name))
  345.                         {
  346.                             struct Node *node;
  347.                             if(node=GetUserNode(name,EXCLUSIVE_LOCK))
  348.                                 {
  349.                                     if(infobuffered) UnLoadUserData(node,UNTAG_UserInfo);
  350.                                     if(accessbuffered) UnLoadUserData(node,UNTAG_UserAccess);
  351.                                     if(prefsbuffered) UnLoadUserData(node,UNTAG_UserPrefs);
  352.                                     if(statsbuffered) UnLoadUserData(node,UNTAG_UserStats);
  353.                                     FreeUserNode(node);
  354.                                 }
  355.                         }
  356.                 }
  357.         }
  358.         return(ret);
  359.     }
  360.  
  361. ULONG SetUserTags(Tag tag,...)
  362.     {
  363.         return(SetUser((struct TagItem *) &tag));
  364.     }
  365.  
  366. __asm
  367. BOOL AddUser(register __a0 struct TagItem *tags_orig)
  368.     {
  369.         BOOL ret=FALSE;
  370.         STRPTR username=NULL;
  371.         STRPTR realname=NULL;
  372.         STRPTR uucpname=NULL;
  373.         BOOL dontsave=FALSE;
  374.         {
  375.             struct TagItem *tags;
  376.             if(tags=CloneTagItems(tags_orig))
  377.                 {
  378.                     if(FilterTagItems(tags,usr_add_tags,TAGFILTER_AND))
  379.                         {
  380.                             struct TagItem *tstate,*tag;
  381.                             APTR data;
  382.                             tstate=tags;
  383.                             while(tag=NextTagItem(&tstate))
  384.                                 {
  385.                                     data=(APTR) tag->ti_Data;
  386.                                     switch(tag->ti_Tag)
  387.                                         {
  388.                                             case USRTAG_UserName:
  389.                                                 username=data;
  390.                                                 break;
  391.                                             case USRTAG_RealName:
  392.                                                 realname=data;
  393.                                                 break;
  394.                                             case USRTAG_UUCPName:
  395.                                                 uucpname=data;
  396.                                                 break;
  397.                                             case USRTAG_DontSave:
  398.                                                 dontsave=(BOOL) data;
  399.                                                 break;
  400.                                             default:
  401.                                                 break;
  402.                                         }
  403.                                 }
  404.                         }
  405.                     FreeTagItems(tags);
  406.                 }
  407.         }
  408.         {
  409.             if( (username && strlen(username) && strlen(username)<=32) || (realname && strlen(realname) && strlen(realname)<=30) || (uucpname && strlen(uucpname) && strlen(uucpname)<=8) )
  410.                 {
  411.                     BOOL ok=TRUE;
  412.                     ObtainSemaphore(&UserSemaphore);
  413.                     if(username && strlen(username))
  414.                         {
  415.                             if(FindUser(username))
  416.                                 ok=FALSE;
  417.                         }
  418.                     if(realname && strlen(realname))
  419.                         {
  420.                             if(FindUser(realname))
  421.                                 ok=FALSE;
  422.                         }
  423.                     if(uucpname && strlen(uucpname))
  424.                         {
  425.                             if(FindUser(uucpname))
  426.                                 ok=FALSE;
  427.                         }
  428.                     if(ok)
  429.                         {
  430.                             struct Node *wn;
  431.                             if(wn=AllocVec(sizeof(struct UserNode),MEMF_CLEAR))
  432.                                 {
  433.                                     InitSemaphore(&(((struct UserNode *) wn)->un_Semaphore));
  434.                                     {
  435.                                         ULONG count=1;
  436.                                         int i=0;
  437.                                         while(usernode_tags[i]!=TAG_END)
  438.                                             {
  439.                                                 count++;
  440.                                                 i++;
  441.                                             }
  442.                                         ((struct UserNode *) wn)->un_Offsets=AllocateTagItems(count);
  443.                                         ((struct UserNode *) wn)->un_Pointers=AllocateTagItems(count);
  444.                                         if(((struct UserNode *) wn)->un_Offsets && ((struct UserNode *) wn)->un_Pointers)
  445.                                             {
  446.                                                 for(i=0;i<count;i++)
  447.                                                     {
  448.                                                         ((struct UserNode *) wn)->un_Offsets[i].ti_Tag=usernode_tags[i];
  449.                                                         ((struct UserNode *) wn)->un_Offsets[i].ti_Data=(usernode_tags[i]==TAG_END) ? (ULONG) 0 : (ULONG) ~0;
  450.                                                         ((struct UserNode *) wn)->un_Pointers[i].ti_Tag=usernode_tags[i];
  451.                                                         ((struct UserNode *) wn)->un_Pointers[i].ti_Data=(ULONG) 0;
  452.                                                     }
  453.                                                 if(username) strcpy(((struct UserNode *) wn)->un_UserName,username);
  454.                                                 if(realname) strcpy(((struct UserNode *) wn)->un_RealName,realname);
  455.                                                 if(uucpname) strcpy(((struct UserNode *) wn)->un_UUCPName,uucpname);
  456.                                                 {
  457.                                                     BYTE dir[256];
  458.                                                     sprintf(dir,"WWBBS:Users/%s",uucpname);
  459.                                                     if(create_dir(dir))
  460.                                                         {
  461.                                                             AddTail(&UserList,wn);
  462.                                                             ret=TRUE;
  463.                                                         }
  464.                                                 }
  465.                                             }
  466.                                     }
  467.                                     if(!ret)
  468.                                         {
  469.                                             if(((struct UserNode *) wn)->un_Offsets) FreeTagItems(((struct UserNode *) wn)->un_Offsets);
  470.                                             if(((struct UserNode *) wn)->un_Pointers) FreeTagItems(((struct UserNode *) wn)->un_Pointers);
  471.                                             FreeVec(wn);
  472.                                         }
  473.                                 }
  474.                         }
  475.                     ReleaseSemaphore(&UserSemaphore);
  476.                 }
  477.         }
  478.         if(ret && !dontsave)
  479.             SaveUserIndex(UserIndexFile);
  480.         return(ret);
  481.     }
  482.  
  483. BOOL AddUserTags(Tag tag,...)
  484.     {
  485.         return(AddUser((struct TagItem *) &tag));
  486.     }
  487.  
  488. __asm
  489. BOOL RemUser(register __a0 struct TagItem *tags_orig)
  490.     {
  491.         BOOL ret=FALSE;
  492.         STRPTR name=NULL;
  493.         BOOL dontsave=FALSE;
  494.         {
  495.             struct TagItem *tags;
  496.             if(tags=CloneTagItems(tags_orig))
  497.                 {
  498.                     if(FilterTagItems(tags,usr_rem_tags,TAGFILTER_AND))
  499.                         {
  500.                             struct TagItem *tstate,*tag;
  501.                             APTR data;
  502.                             tstate=tags;
  503.                             while(tag=NextTagItem(&tstate))
  504.                                 {
  505.                                     data=(APTR) tag->ti_Data;
  506.                                     switch(tag->ti_Tag)
  507.                                         {
  508.                                             case USRTAG_Name:
  509.                                                 name=data;
  510.                                                 break;
  511.                                             case USRTAG_DontSave:
  512.                                                 dontsave=(BOOL) data;
  513.                                                 break;
  514.                                             default:
  515.                                                 break;
  516.                                         }
  517.                                 }
  518.                         }
  519.                     FreeTagItems(tags);
  520.                 }
  521.         }
  522.         {
  523.             if(name && strlen(name))
  524.                 {
  525.                     ObtainSemaphore(&UserSemaphore);
  526.                     {
  527.                         struct Node *node;
  528.                         if(node=FindUser(name))
  529.                             {
  530.                                 BYTE dir[256];
  531.                                 sprintf(dir,"WWBBS:Users/%s",((struct UserNode *) node)->un_UUCPName);
  532.                                 delete_dir(dir);
  533.                                 if(DeleteFile(dir))
  534.                                     {
  535.                                         Remove(node);
  536.                                         FreeTagItems(((struct UserNode *) node)->un_Offsets);
  537.                                         {
  538.                                             struct TagItem *tstate,*tag;
  539.                                             tstate=((struct UserNode *) node)->un_Pointers;
  540.                                             while(tag=NextTagItem(&tstate))
  541.                                                 {
  542.                                                     if(tag->ti_Data)
  543.                                                         FreeVec((APTR) tag->ti_Data);
  544.                                                 }
  545.                                         }
  546.                                         FreeTagItems(((struct UserNode *) node)->un_Pointers);
  547.                                         FreeVec(node);
  548.                                         ret=TRUE;
  549.                                     }
  550.                             }
  551.  
  552.                     }
  553.                     ReleaseSemaphore(&UserSemaphore);
  554.                 }
  555.         }
  556.         if(ret && !dontsave)
  557.             {
  558.                 SaveUserData(UserInfoFile,UNTAG_UserInfo);
  559.                 SaveUserData(UserAccessFile,UNTAG_UserAccess);
  560.                 SaveUserData(UserPrefsFile,UNTAG_UserPrefs);
  561.                 SaveUserData(UserStatsFile,UNTAG_UserStats);
  562.                 SaveUserIndex(UserIndexFile);
  563.             }
  564.         return(ret);
  565.     }
  566.  
  567. BOOL RemUserTags(Tag tag,...)
  568.     {
  569.         return(RemUser((struct TagItem *) &tag));
  570.     }
  571.  
  572. __asm
  573. BOOL LoadUser(register __a0 struct TagItem *tags_orig)
  574.     {
  575.         BOOL ret=FALSE;
  576.         STRPTR name=NULL;
  577.         {
  578.             struct TagItem *tags;
  579.             if(tags=CloneTagItems(tags_orig))
  580.                 {
  581.                     if(FilterTagItems(tags,usr_load_tags,TAGFILTER_AND))
  582.                         {
  583.                             struct TagItem *tstate,*tag;
  584.                             APTR data;
  585.                             tstate=tags;
  586.                             while(tag=NextTagItem(&tstate))
  587.                                 {
  588.                                     data=(APTR) tag->ti_Data;
  589.                                     switch(tag->ti_Tag)
  590.                                         {
  591.                                             case USRTAG_Name:
  592.                                                 name=data;
  593.                                                 break;
  594.                                             default:
  595.                                                 break;
  596.                                         }
  597.                                 }
  598.                         }
  599.                     FreeTagItems(tags);
  600.                 }
  601.         }
  602.         {
  603.             if(name && strlen(name))
  604.                 {
  605.                     struct Node *node;
  606.                     if(node=GetUserNode(name,EXCLUSIVE_LOCK))
  607.                         {
  608.                             ret=TRUE;
  609.                             if(!LoadUserData(UserInfoFile,node,UNTAG_UserInfo))
  610.                                 ret=FALSE;
  611.                             if(!LoadUserData(UserAccessFile,node,UNTAG_UserAccess))
  612.                                 ret=FALSE;
  613.                             if(!LoadUserData(UserPrefsFile,node,UNTAG_UserPrefs))
  614.                                 ret=FALSE;
  615.                             if(!LoadUserData(UserStatsFile,node,UNTAG_UserStats))
  616.                                 ret=FALSE;
  617.                             FreeUserNode(node);
  618.                         }
  619.                 }
  620.         }
  621.         return(ret);
  622.     }
  623.  
  624. BOOL LoadUserTags(Tag tag,...)
  625.     {
  626.         return(LoadUser((struct TagItem *) &tag));
  627.     }
  628.  
  629. __asm
  630. VOID UnLoadUser(register __a0 struct TagItem *tags_orig)
  631.     {
  632.         STRPTR name=NULL;
  633.         {
  634.             struct TagItem *tags;
  635.             if(tags=CloneTagItems(tags_orig))
  636.                 {
  637.                     if(FilterTagItems(tags,usr_unload_tags,TAGFILTER_AND))
  638.                         {
  639.                             struct TagItem *tstate,*tag;
  640.                             APTR data;
  641.                             tstate=tags;
  642.                             while(tag=NextTagItem(&tstate))
  643.                                 {
  644.                                     data=(APTR) tag->ti_Data;
  645.                                     switch(tag->ti_Tag)
  646.                                         {
  647.                                             case USRTAG_Name:
  648.                                                 name=data;
  649.                                                 break;
  650.                                             default:
  651.                                                 break;
  652.                                         }
  653.                                 }
  654.                         }
  655.                     FreeTagItems(tags);
  656.                 }
  657.         }
  658.         {
  659.             if(name && strlen(name))
  660.                 {
  661.                     {
  662.                         SaveUserData(UserInfoFile,UNTAG_UserInfo);
  663.                         SaveUserData(UserAccessFile,UNTAG_UserAccess);
  664.                         SaveUserData(UserPrefsFile,UNTAG_UserPrefs);
  665.                         SaveUserData(UserStatsFile,UNTAG_UserStats);
  666.                         SaveUserIndex(UserIndexFile);
  667.                     }
  668.                     {
  669.                         struct Node *node;
  670.                         if(node=GetUserNode(name,EXCLUSIVE_LOCK))
  671.                             {
  672.                                 UnLoadUserData(node,UNTAG_UserInfo);
  673.                                 UnLoadUserData(node,UNTAG_UserAccess);
  674.                                 UnLoadUserData(node,UNTAG_UserPrefs);
  675.                                 UnLoadUserData(node,UNTAG_UserStats);
  676.                                 FreeUserNode(node);
  677.                             }
  678.                     }
  679.                 }
  680.         }
  681.     }
  682.  
  683. VOID UnLoadUserTags(Tag tag,...)
  684.     {
  685.         UnLoadUser((struct TagItem *) &tag);
  686.     }
  687.  
  688. BOOL create_dir(BYTE *dir)
  689.     {
  690.         BPTR fh;
  691.         BOOL ret=FALSE;
  692.         if(fh=CreateDir(dir))
  693.             {
  694.                 UnLock(fh);
  695.                 ret=TRUE;
  696.             }
  697.         return(ret);
  698.     }
  699.  
  700. void delete_dir(BYTE *dir)
  701.     {
  702.         BPTR lock,old_dir;
  703.         if(lock=Lock(dir,SHARED_LOCK))
  704.             {
  705.                 old_dir=CurrentDir(lock);
  706.                 {
  707.                     struct ExAllControl *eac;
  708.                     if(eac=AllocDosObject(DOS_EXALLCONTROL,NULL))
  709.                         {
  710.                             APTR data;
  711.                             if(data=AllocVec(sizeof(BYTE)*16384,MEMF_CLEAR))
  712.                                 {
  713.                                     BOOL more;
  714.                                     eac->eac_LastKey=0;
  715.                                     do
  716.                                         {
  717.                                             more=ExAll(lock,data,sizeof(BYTE)*16384,ED_TYPE,eac);
  718.                                             if((!more) && (IoErr()!=ERROR_NO_MORE_ENTRIES))
  719.                                                 break;
  720.                                             if(eac->eac_Entries==0)
  721.                                                 continue;
  722.                                             {
  723.                                                 struct ExAllData *ead;
  724.                                                 ead=(struct ExAllData *) data;
  725.                                                 do
  726.                                                     {
  727.                                                         if(ead->ed_Type<0) /* plain file */
  728.                                                             DeleteFile(ead->ed_Name);
  729.                                                         if(ead->ed_Type>=0) /* directory */
  730.                                                             delete_dir(ead->ed_Name);
  731.                                                         ead=ead->ed_Next;
  732.                                                     }
  733.                                                 while(ead);
  734.                                             }
  735.                                         }
  736.                                     while(more);
  737.                                     FreeVec(data);
  738.                                 }
  739.                             FreeDosObject(DOS_EXALLCONTROL,eac);
  740.                         }
  741.                 }
  742.                 CurrentDir(old_dir);
  743.                 UnLock(lock);
  744.             }
  745.     }
  746.